home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / ULARN.ARJ / ULARN.TAR / ularn / global.c < prev    next >
C/C++ Source or Header  |  1989-10-25  |  19KB  |  1,023 lines
  1. /*    global.c
  2.  *
  3.  *    raiselevel()        subroutine to raise the player one level
  4.  *    loselevel()        subroutine to lower the player by one level
  5.  *    raiseexperience(x)    subroutine to increase experience points
  6.  *    loseexperience(x)    subroutine to lose experience points
  7.  *    losehp(x)        subroutine to remove hit points from the player
  8.  *    losemhp(x)        subroutine to remove max # hit points from 
  9.  *                the player
  10.  *    raisehp(x)        subroutine to gain hit points
  11.  *    raisemhp(x)        subroutine to gain maximum hit points
  12.  *    losespells(x)        subroutine to lose spells
  13.  *    losemspells(x)        subroutine to lose maximum spells
  14.  *    raisespells(x)        subroutine to gain spells
  15.  *    raisemspells(x)        subroutine to gain maximum spells
  16.  *    recalc()        function to recalculate the armor class of 
  17.  *                the player
  18.  *    makemonst(lev)        function to return monster number for a randomly
  19.  *                selected monster
  20.  *    positionplayer()    function to be sure player is not in a wall
  21.  *    quit()            subroutine to ask if the player really wants 
  22.  *                to quit
  23.  */
  24.  
  25. #include "header.h"
  26. extern int score[],srcount,dropflag;
  27. extern int random;/*    the random number seed            */
  28. extern short playerx,playery,lastnum;
  29. extern char cheat,level,monstnamelist[];
  30. extern char lastmonst[],*what[],*who[]; 
  31. extern char winner[];
  32. extern char logname[],monstlevel[];
  33. extern char sciv[SCORESIZE+1][26][2],*potionname[],*scrollname[];
  34. /*
  35.     ***********
  36.     RAISE LEVEL
  37.     ***********
  38.     raiselevel()
  39.  
  40.     subroutine to raise the player one level
  41.     uses the skill[] array to find level boundarys
  42.     uses c[EXPERIENCE]  c[LEVEL]
  43.  */
  44. raiselevel()
  45. {
  46.     if (c[LEVEL] < MAXPLEVEL) 
  47.         raiseexperience((long)(skill[c[LEVEL]]-c[EXPERIENCE]));
  48. }
  49.  
  50. /*
  51.     ***********
  52.     LOOSE LEVEL
  53.     ***********
  54.     loselevel()
  55.  
  56.     subroutine to lower the players character level by one
  57.  */
  58. loselevel()
  59. {
  60.     if (c[LEVEL] > 1) loseexperience((long)(c[EXPERIENCE] - skill[c[LEVEL]-1] + 1));
  61. }
  62.  
  63. /*
  64.     ****************
  65.     RAISE EXPERIENCE
  66.     ****************
  67.     raiseexperience(x)
  68.  
  69.     subroutine to increase experience points
  70.  */
  71. raiseexperience(x)
  72. register long x;
  73. {
  74.     register int i,tmp;
  75.  
  76.     i=c[LEVEL];    
  77.     c[EXPERIENCE]+=x;
  78.     while (c[EXPERIENCE] >= skill[c[LEVEL]] && (c[LEVEL] < MAXPLEVEL)) {
  79.         tmp = (c[CONSTITUTION]-c[HARDGAME])>>1;
  80.         c[LEVEL]++;    
  81.         raisemhp((int)(rnd(3)+rnd((tmp>0)?tmp:1)));
  82.         raisemspells((int)rund(3));
  83.         if (c[LEVEL] < 7-c[HARDGAME]) 
  84.             raisemhp((int)(c[CONSTITUTION]>>2));
  85.     }
  86.     if (c[LEVEL] != i) {
  87.         cursors();
  88.         beep(); 
  89.         lprintf("\nWelcome to level %d",(long)c[LEVEL]);    
  90.         /* if we changed levels    */
  91.         switch (c[LEVEL]) {
  92.         case 94:    /* earth guardian */
  93.             c[WTW] = 99999L;
  94.             break;
  95.         case 95:     /* air guardian */
  96.             c[INVISIBILITY] = 99999L;
  97.             break;
  98.         case 96:    /* fire guardian */
  99.             c[FIRERESISTANCE] = 99999L;
  100.             break;
  101.         case 97:     /* water guardian */
  102.             c[CANCELLATION] = 99999L;
  103.             break;
  104.         case 98:     /* time guardian */
  105.             c[HASTESELF] = 99999L;
  106.             break;
  107.         case 99:    /* ethereal guardian */
  108.             c[STEALTH] = 99999L;
  109.             c[SPIRITPRO] = 99999L;
  110.             break;
  111.         case 100:
  112.             lprcat("\nYou are now The Creator ");
  113.             {
  114.                 register int i,j;
  115.  
  116.                 for (i=0; i<MAXY; i++)
  117.                     for (j=0; j<MAXX; j++)  
  118.                         know[j][i]=1;
  119.                 for (i=0; i<SPNUM; i++)    
  120.                     spelknow[i]=1;
  121.                 for (i=0; i<MAXSCROLL; i++)  
  122.                     scrollname[i][0]=' ';
  123.                 for (i=0; i<MAXPOTION; i++)  
  124.                     potionname[i][0]=' ';
  125.             }
  126. /*            c[STEALTH] = 99999L;
  127.             c[UNDEADPRO] = 99999L;
  128.             c[SPIRITPRO] = 99999L;
  129.             c[CHARMCOUNT] = 99999L;
  130.             c[GIANTSTR] = 99999L;
  131.             c[FIRERESISTANCE] = 99999L;
  132.             c[DEXCOUNT] = 99999L;
  133.             c[STRCOUNT] = 99999L;
  134.             c[SCAREMONST] = 99999L;
  135.             c[HASTESELF] = 99999L;
  136.             c[CANCELLATION] = 99999L;
  137.             c[INVISIBILITY] = 99999L;
  138.             c[ALTPRO] = 99999L;
  139.             c[WTW] = 99999L;
  140.             c[AWARENESS] = 99999L;
  141. */
  142.             break;
  143.         }
  144.     }
  145. }
  146.  
  147. /*
  148.     ****************
  149.     LOOSE EXPERIENCE
  150.     ****************
  151.     loseexperience(x)
  152.  
  153.     subroutine to lose experience points
  154.  */
  155. loseexperience(x)
  156. register long x;
  157. {
  158.     register int i,tmp;
  159.  
  160.     i=c[LEVEL];        
  161.     c[EXPERIENCE]-=x;
  162.     if (c[EXPERIENCE] < 0) c[EXPERIENCE]=0;
  163.     while (c[EXPERIENCE] < skill[c[LEVEL]-1])
  164.     {
  165.         if (--c[LEVEL] <= 1) 
  166.             c[LEVEL]=1;    /*    down one level        */
  167.         tmp = (c[CONSTITUTION]-c[HARDGAME])>>1;    /* lose hpoints */
  168.         losemhp((int)rnd((tmp>0)?tmp:1));    /* lose hpoints */
  169.         if (c[LEVEL] < 7-c[HARDGAME]) 
  170.             losemhp((int)(c[CONSTITUTION]>>2));
  171.         losemspells((int)rund(3));    /*    lose spells */
  172.     }
  173.     if (i!=c[LEVEL])
  174.     {
  175.         cursors();
  176.         beep(); 
  177.         lprintf("\nYou went down to level %d!",(long)c[LEVEL]);
  178.     }
  179.     bottomline();
  180. }
  181.  
  182. /*
  183.     ********
  184.     LOOSE HP
  185.     ********
  186.     losehp(x)
  187.     losemhp(x)
  188.  
  189.     subroutine to remove hit points from the player
  190.     warning -- will kill player if hp goes to zero
  191.  */
  192. losehp(x)
  193. register int x;
  194. {
  195.     if ((c[HP] -= x) <= 0)
  196.     {
  197.         beep(); 
  198.         lprcat("\n");  
  199.         nap(3000);  
  200.         died(lastnum);
  201.     }
  202. }
  203.  
  204. losemhp(x)
  205. register int x;
  206. {
  207.     c[HP] -= x;        
  208.     if (c[HP] < 1)        
  209.         c[HP]=1;
  210.     c[HPMAX] -= x;    
  211.     if (c[HPMAX] < 1)    
  212.         c[HPMAX]=1;
  213. }
  214.  
  215. /*
  216.     ********
  217.     RAISE HP
  218.     ********
  219.     raisehp(x)
  220.     raisemhp(x)
  221.  
  222.     subroutine to gain maximum hit points
  223.  */
  224. raisehp(x)
  225. register int x;
  226. {
  227.     if ((c[HP] += x) > c[HPMAX]) c[HP] = c[HPMAX];
  228. }
  229.  
  230. raisemhp(x)
  231. register int x;
  232. {
  233.     c[HPMAX] += x;    
  234.     c[HP] += x;
  235. }
  236.  
  237. /*
  238.     ************
  239.     RAISE SPELLS
  240.     ************
  241.     raisespells(x)
  242.     raisemspells(x)
  243.  
  244.     subroutine to gain maximum spells
  245.  */
  246. raisespells(x)
  247. register int x;
  248. {
  249.     if ((c[SPELLS] += x) > c[SPELLMAX])    c[SPELLS] = c[SPELLMAX];
  250. }
  251.  
  252. raisemspells(x)
  253. register int x;
  254. {
  255.     c[SPELLMAX]+=x; 
  256.     c[SPELLS]+=x;
  257. }
  258.  
  259. /*
  260.     ************
  261.     LOSE SPELLS
  262.     ************
  263.     losespells(x)
  264.     losemspells(x)
  265.  
  266.     subroutine to lose maximum spells
  267.  */
  268. losespells(x)
  269. register int x;
  270. {
  271.     if ((c[SPELLS] -= x) < 0) c[SPELLS]=0;
  272. }
  273.  
  274. losemspells(x)
  275. register int x;
  276. {
  277.     if ((c[SPELLMAX] -= x) < 0) c[SPELLMAX]=0;
  278.     if ((c[SPELLS] -= x) < 0) c[SPELLS]=0;
  279. }
  280.  
  281. /*
  282.     makemonst(lev)
  283.     int lev;
  284.  
  285.     function to return monster number for a randomly selected monster
  286.         for the given cave level    
  287.  */
  288. makemonst(lev)
  289. register int lev;
  290. {
  291.     register int tmp,x;
  292.  
  293.  
  294.     if (lev < 1)    
  295.         lev = 1;
  296.     if (lev > 12)    
  297.         lev = 12;
  298.  
  299.     tmp=WATERLORD;
  300.  
  301.     if (lev < 5) 
  302.         while (tmp==WATERLORD) 
  303.             tmp=rnd((x=monstlevel[lev-1])?x:1);
  304.  
  305.     else while (tmp==WATERLORD)
  306.         tmp=rnd((x=monstlevel[lev-1]-monstlevel[lev-4])?x:1)+monstlevel[lev-4];
  307.  
  308.     while (monster[tmp].genocided && tmp<MAXMONST) tmp++; /* genocided? */
  309.  
  310.     if (level < 16)
  311.         if (rnd(100)<10) tmp=LEMMING;
  312.  
  313.     return(tmp);
  314. }
  315.  
  316. /*
  317.     positionplayer()
  318.  
  319.     function to be sure player is not in a wall
  320.  */
  321. positionplayer()
  322. {
  323.     int try;
  324.     try = 2;
  325.  
  326.     while ((item[playerx][playery] || mitem[playerx][playery]) && (try))
  327.         if (++playerx >= MAXX-1)
  328.         {
  329.             playerx = 1;
  330.             if (++playery >= MAXY-1)
  331.             {    
  332.                 playery = 1;    
  333.                 --try;    
  334.             }
  335.         }
  336.     if (try==0)     lprcat("Failure in positionplayer\n");
  337. }
  338.  
  339. /*
  340.     recalc()    function to recalculate the armor class of the player
  341.  */
  342. recalc()
  343. {
  344.     register int i,j,k;
  345.  
  346.     c[AC] = c[MOREDEFENSES];
  347.     if (c[WEAR] >= 0)
  348.         switch(iven[c[WEAR]]) {
  349.         case OSHIELD:        
  350.             c[AC] += 2 + ivenarg[c[WEAR]]; 
  351.             break;
  352.         case OLEATHER:        
  353.             c[AC] += 2 + ivenarg[c[WEAR]]; 
  354.             break;
  355.         case OSTUDLEATHER:    
  356.             c[AC] += 3 + ivenarg[c[WEAR]]; 
  357.             break;
  358.         case ORING:            
  359.             c[AC] += 5 + ivenarg[c[WEAR]]; 
  360.             break;
  361.         case OCHAIN:        
  362.             c[AC] += 6 + ivenarg[c[WEAR]]; 
  363.             break;
  364.         case OSPLINT:        
  365.             c[AC] += 7 + ivenarg[c[WEAR]]; 
  366.             break;
  367.         case OPLATE:        
  368.             c[AC] += 9 + ivenarg[c[WEAR]]; 
  369.             break;
  370.         case OPLATEARMOR:    
  371.             c[AC] += 10 + ivenarg[c[WEAR]]; 
  372.             break;
  373.         case OSSPLATE:        
  374.             c[AC] += 12 + ivenarg[c[WEAR]]; 
  375.             break;
  376.         case OELVENCHAIN:
  377.             c[AC] += 15 + ivenarg[c[WEAR]]; 
  378.             break;
  379.         }
  380.  
  381.     if (c[SHIELD] >= 0) if (iven[c[SHIELD]] == OSHIELD) c[AC] += 2 + ivenarg[c[SHIELD]];
  382.     if (c[WIELD] < 0)  c[WCLASS] = 0;  
  383.     else {
  384.         i = ivenarg[c[WIELD]];
  385.         switch(iven[c[WIELD]]) {
  386.         case ODAGGER:    
  387.             c[WCLASS] =  3 + i;  
  388.             break;
  389.         case OBELT:
  390.             c[WCLASS] =  7 + i;  
  391.             break;
  392.         case OSHIELD:     
  393.             c[WCLASS] =  8 + i;  
  394.             break;
  395.         case OPSTAFF:
  396.         case OSPEAR:     
  397.             c[WCLASS] = 10 + i;  
  398.             break;
  399.         case OFLAIL:     
  400.             c[WCLASS] = 14 + i;  
  401.             break;
  402.         case OBATTLEAXE: 
  403.             c[WCLASS] = 17 + i;  
  404.             break;
  405.         case OLANCE:     
  406.             c[WCLASS] = 20 + i;  
  407.             break;
  408.         case OLONGSWORD: 
  409.             c[WCLASS] = 22 + i;  
  410.             break;
  411.         case O2SWORD:    
  412.             c[WCLASS] = 26 + i;  
  413.             break;
  414.         case OSWORDofSLASHING: 
  415.             c[WCLASS] = 30 + i; 
  416.             break;
  417.         case OSLAYER:     
  418.             c[WCLASS] = 30 + i; 
  419.             break;
  420.         case OSWORD:     
  421.             c[WCLASS] = 32 + i;  
  422.             break;
  423.         case OHAMMER:    
  424.             c[WCLASS] = 35 + i;  
  425.             break;
  426.         default:         
  427.             c[WCLASS] = 0;
  428.         }
  429.     }
  430.     c[WCLASS] += c[MOREDAM];
  431.  
  432.     /*    now for regeneration abilities based on rings    */
  433.     c[REGEN]=1;        
  434.     c[ENERGY]=0;
  435.     j=0;  
  436.     for (k=25; k>0; k--)  if (iven[k]) {
  437.         j=k; 
  438.         k=0; 
  439.     }
  440.     for (i=0; i<=j; i++) {
  441.         switch(iven[i]) {
  442.         case OPROTRING: 
  443.             c[AC]     += ivenarg[i] + 1;    
  444.             break;
  445.         case ODAMRING:  
  446.             c[WCLASS] += ivenarg[i] + 1;    
  447.             break;
  448.         case OBELT:     
  449.             c[WCLASS] += ((ivenarg[i]<<1)) + 2;    
  450.             break;
  451.  
  452.         case OREGENRING:    
  453.             c[REGEN]  += ivenarg[i] + 1;    
  454.             break;
  455.         case ORINGOFEXTRA:    
  456.             c[REGEN]  += 5 * (ivenarg[i]+1); 
  457.             break;
  458.         case OENERGYRING:    
  459.             c[ENERGY] += ivenarg[i] + 1;    
  460.             break;
  461.         }
  462.     }
  463. }
  464.  
  465.  
  466. /*
  467.     quit()
  468.  
  469.     subroutine to ask if the player really wants to quit
  470.  */
  471. quit()
  472. {
  473.     register int i;
  474.  
  475.     cursors();
  476.     strcpy(lastmonst,"");
  477.     lprcat("\n\nDo you really want to quit? (y)es, (n)o, (s)ave");
  478.     while (1) {
  479.         i=getcharacter();
  480.         if (i == 'y')    { 
  481.             died(300); 
  482.             return; 
  483.         }
  484.         if ((i == 'n') || (i == '\33'))    { 
  485.             lprcat(" no"); 
  486.             lflush(); 
  487.             return; 
  488.         }
  489.         if (i == 's') {
  490.             lprcat(" save");
  491.             lflush();
  492.             clear();  
  493.             lprcat("Saving . . ."); 
  494.             lflush();  
  495.             savegame(savefilename); 
  496.             wizard=1; 
  497.             died(-257);
  498.         }
  499.         lprcat("\n");  
  500.         if (boldon) setbold();  
  501.         lprcat("Yes");  
  502.         if (boldon) resetbold();  
  503.         lprcat(" ");
  504.         if (boldon) setbold();  
  505.         lprcat("Save");
  506.         if (boldon) resetbold();  
  507.         lprcat(" or ");
  508.         if (boldon) setbold();  
  509.         lprcat("No");  
  510.         if (boldon) resetbold();  
  511.         lprcat(" please?   Do you want to quit? ");
  512.     }
  513. }
  514.  
  515. /*
  516.     function to ask --more-- then the user must enter a space
  517.  */
  518. more()
  519. {
  520.     lprcat("\n  --- press ");  
  521.     standout("space");  
  522.     lprcat(" to continue --- ");
  523.     while (getcharacter() != ' ');
  524. }
  525.  
  526. /*
  527.     function to put something in the players inventory
  528.     returns 0 if success, 1 if a failure
  529.  */
  530. take(itm,arg)
  531. int itm,arg;
  532. {
  533.     register int i,limit;
  534.  
  535.     /*    cursors(); */
  536.     if ((limit = 15+(c[LEVEL]>>1)) > 26)  limit=26;
  537.     for (i=0; i<limit; i++)
  538.         if (iven[i]==0) {
  539.             iven[i] = itm;  
  540.             ivenarg[i] = arg;  
  541.             limit=0;
  542.             switch(itm) {
  543.             case OPROTRING:    
  544.             case ODAMRING: 
  545.             case OBELT:     
  546.                 limit=1;  
  547.                 break;
  548.             case ODEXRING:    
  549.                 c[DEXTERITY] += ivenarg[i]+1; 
  550.                 limit=1;    
  551.                 break;
  552.             case OSTRRING:    
  553.                 c[STREXTRA]  += ivenarg[i]+1;
  554.                 limit=1; 
  555.                 break;
  556.             case OCLEVERRING:
  557.                 c[INTELLIGENCE] += ivenarg[i]+1;
  558.                 limit=1; 
  559.                 break;
  560.             case OHAMMER:    
  561.                 c[DEXTERITY] += 10;    
  562.                 c[STREXTRA]+=10;
  563.                 c[INTELLIGENCE]-=10;    
  564.                 limit=1;     
  565.                 break;
  566.             case OORB:    
  567.                 c[ORB]++;
  568.                 c[AWARENESS]++;
  569.                 break;
  570.             case OORBOFDRAGON:
  571.                 c[SLAYING]++;        
  572.                 break;
  573.             case OSPIRITSCARAB: 
  574.                 c[NEGATESPIRIT]++;    
  575.                 break;
  576.             case OCUBEofUNDEAD: 
  577.                 c[CUBEofUNDEAD]++;    
  578.                 break;
  579.             case ONOTHEFT:    
  580.                 c[NOTHEFT]++;        
  581.                 break;
  582.             case OSWORDofSLASHING:    
  583.                 c[DEXTERITY] +=5;    
  584.                 limit=1; 
  585.                 break;
  586.             case OSLAYER:
  587.                 c[INTELLIGENCE]+=10;
  588.                 break;
  589.             case OPSTAFF:
  590.                 c[WISDOM]+=10;
  591.                 break;
  592.             case  OLARNEYE:
  593.                 monstnamelist[DEMONLORD] = '1';
  594.                 monstnamelist[DEMONLORD+1] = '2';
  595.                 monstnamelist[DEMONLORD+2] = '3';
  596.                 monstnamelist[DEMONLORD+3] = '4';
  597.                 monstnamelist[DEMONLORD+4] = '5';
  598.                 monstnamelist[DEMONLORD+5] = '6';
  599.                 monstnamelist[DEMONLORD+6] = '7';
  600.                 monstnamelist[DEMONPRINCE] = '9';
  601.                 monstnamelist[LUCIFER] = '0';
  602.                 break;
  603.             };
  604.  
  605.             lprcat("\nYou pick up:"); 
  606.             srcount=0;  
  607.             show3(i);
  608.             if (limit) bottomline();  
  609.             return(0);
  610.         }
  611.     lprcat("\nYou can't carry anything else");  
  612.     return(1);
  613. }
  614.  
  615. /*
  616.     subroutine to drop an object  returns 1 if something there already else 
  617.  
  618.     k is index into iven list of object to drop
  619.  */
  620.  
  621. drop_object(k)
  622. int k;
  623. {
  624.     int itm;
  625.  
  626.     if ((k<0) || (k>25)) return(0);
  627.     itm = iven[k];
  628.     cursors();
  629.     if (itm==0) { 
  630.         lprintf("\nYou don't have item %c! ",k+'a'); 
  631.         return(1); 
  632.     }
  633.     if (item[playerx][playery]) { 
  634.         beep(); 
  635.         lprcat("\nThere's something here already"); 
  636.         return(1); 
  637.     }
  638.     if (playery==MAXY-1 && playerx==33) 
  639.         return(1); /* not in entrance */
  640.  
  641.     item[playerx][playery] = itm;
  642.     iarg[playerx][playery] = ivenarg[k];
  643.  
  644.     srcount=0; 
  645.     lprcat("\n  You drop:"); 
  646.     show3(k); /* show what item you dropped*/
  647.     know[playerx][playery] = 0;  
  648.     iven[k]=0;
  649.     if (c[WIELD]==k) 
  650.         c[WIELD]= -1;
  651.     if (c[WEAR]==k)  
  652.         c[WEAR] = -1;
  653.     if (c[SHIELD]==k) 
  654.         c[SHIELD]= -1;
  655.     adjustcvalues(itm,ivenarg[k]);
  656.     if (itm==OLANCE) recalc();
  657. /* say dropped an item so wont ask to pick it up right away */
  658.     dropflag=1;
  659.     return(0);
  660. }
  661.  
  662. /*
  663.     function to enchant armor player is currently wearing
  664.  */
  665. enchantarmor()
  666. {
  667.     register int tmp;
  668.     if (c[WEAR]<0) { 
  669.         if (c[SHIELD] < 0)
  670.         { 
  671.             cursors(); 
  672.             beep(); 
  673.             lprcat("\nYou feel a sense of loss"); 
  674.             return; 
  675.         }
  676.         else { 
  677.             tmp=iven[c[SHIELD]]; 
  678.             if (tmp != OSCROLL) if (tmp != OPOTION) { 
  679.                 ivenarg[c[SHIELD]]++; 
  680.                 bottomline(); 
  681.             } 
  682.         } 
  683.     }
  684.     tmp = iven[c[WEAR]];
  685.     if (tmp!=OSCROLL) if (tmp!=OPOTION)  { 
  686.         ivenarg[c[WEAR]]++;  
  687.         bottomline(); 
  688.     }
  689. }
  690.  
  691. /*
  692.     function to enchant a weapon presently being wielded
  693.  */
  694. enchweapon()
  695. {
  696.     register int tmp;
  697.  
  698.     if (c[WIELD]<0) { 
  699.         cursors(); 
  700.         beep(); 
  701.         lprcat("\nYou feel depressed"); 
  702.         return; 
  703.     }
  704.     tmp = iven[c[WIELD]];
  705.     if (tmp!=OSCROLL) if (tmp!=OPOTION) { 
  706.         ivenarg[c[WIELD]]++;
  707.         if (tmp==OCLEVERRING) c[INTELLIGENCE]++;  
  708.         else
  709.             if (tmp==OSTRRING)    c[STREXTRA]++;  
  710.             else
  711.                 if (tmp==ODEXRING)    c[DEXTERITY]++;          
  712.         bottomline(); 
  713.     }
  714. }
  715.  
  716. /*
  717.     routine to tell if player can carry one more thing
  718.     returns 1 if pockets are full, else 0
  719.  */
  720. pocketfull()
  721. {
  722.     register int i,limit; 
  723.     if ((limit = 15+(c[LEVEL]>>1)) > 26)  limit=26;
  724.     for (i=0; i<limit; i++) if (iven[i]==0) return(0);
  725.     return(1);
  726. }
  727.  
  728. /*
  729.     function to return 1 if a monster is next to the player else returns 0
  730.  */
  731. nearbymonst()
  732. {
  733.     register int tmp,tmp2;
  734.     for (tmp=playerx-1; tmp<playerx+2; tmp++)
  735.         for (tmp2=playery-1; tmp2<playery+2; tmp2++)
  736.             if (mitem[tmp][tmp2]) return(1); /* if monster nearby */
  737.     return(0);
  738. }
  739.  
  740. /*
  741.     function to steal an item from the players pockets
  742.     returns 1 if steals something else returns 0
  743.  */
  744. stealsomething()
  745. {
  746.     register int i,j;
  747.  
  748.     j=100;
  749.     while (1) {
  750.         i=rund(26);
  751.         if (iven[i]) if (c[WEAR]!=i) if (c[WIELD]!=i) if (c[SHIELD]!=i) {
  752.             srcount=0; 
  753.             show3(i);
  754.             adjustcvalues(iven[i],ivenarg[i]);  
  755.             iven[i]=0; 
  756.             return(1);
  757.         }
  758.         if (--j <= 0) return(0);
  759.     }
  760. }
  761.  
  762. /*
  763.     function to return 1 is player carrys nothing else return 0
  764.  */
  765. emptyhanded()
  766. {
  767.     register int i;
  768.  
  769.     for (i=0; i<26; i++)
  770.         if (iven[i]) if (i!=c[WIELD]) if (i!=c[WEAR]) if (i!=c[SHIELD]) return(0);
  771.     return(1);
  772. }
  773.  
  774. /*
  775.     function to create a gem on a square near the player
  776.  */
  777. creategem()
  778. {
  779.     register int i,j;
  780.     switch(rnd(4))
  781.     {
  782.     case 1:     
  783.         i=ODIAMOND;    
  784.         j=50;    
  785.         break;
  786.     case 2:     
  787.         i=ORUBY;        
  788.         j=40;    
  789.         break;
  790.     case 3:     
  791.         i=OEMERALD;    
  792.         j=30;    
  793.         break;
  794.     default: 
  795.         i=OSAPPHIRE;    
  796.         j=20;    
  797.         break;
  798.     };
  799.     createitem(i,rnd(j)+j/10);
  800. }
  801.  
  802. /*
  803.     function to change character levels as needed when dropping an object
  804.     that affects these characteristics
  805.  */
  806. adjustcvalues(itm,arg)
  807. int itm,arg;
  808. {
  809.     register int flag,i;
  810.  
  811.     flag=0;
  812.     switch(itm) {
  813.     case ODEXRING:    
  814.         c[DEXTERITY] -= arg+1;  
  815.         flag=1; 
  816.         break;
  817.     case OSTRRING:    
  818.         c[STREXTRA]  -= arg+1;  
  819.         flag=1; 
  820.         break;
  821.     case OCLEVERRING: 
  822.         c[INTELLIGENCE] -= arg+1;  
  823.         flag=1; 
  824.         break;
  825.     case OHAMMER:    
  826.         c[DEXTERITY] -= 10;    
  827.         c[STREXTRA] -= 10;
  828.         c[INTELLIGENCE] += 10; 
  829.         flag=1; 
  830.         break;
  831.     case OORB:    
  832.         c[ORB]--;
  833.         c[AWARENESS]--;
  834.     case OSWORDofSLASHING:        
  835.         c[DEXTERITY] -= 5;
  836.         flag=1; 
  837.         break;
  838.     case OSLAYER:        
  839.         c[INTELLIGENCE]-=10; 
  840.         flag=1; 
  841.         break;
  842.     case OPSTAFF:        
  843.         c[WISDOM]-=10; 
  844.         flag=1;
  845.         break;
  846.     case OORBOFDRAGON:        
  847.         --c[SLAYING];        
  848.         return;
  849.     case OSPIRITSCARAB:        
  850.         --c[NEGATESPIRIT];    
  851.         return;
  852.     case OCUBEofUNDEAD:        
  853.         --c[CUBEofUNDEAD];    
  854.         return;
  855.     case ONOTHEFT:            
  856.         --c[NOTHEFT];         
  857.         return;
  858.     case OLANCE:            
  859.         c[LANCEDEATH]=0;    
  860.         return;
  861.     case OLARNEYE:
  862.         monstnamelist[DEMONLORD] = ' ';
  863.         monstnamelist[DEMONLORD+1] = ' ';
  864.         monstnamelist[DEMONLORD+2] = ' ';
  865.         monstnamelist[DEMONLORD+3] = ' ';
  866.         monstnamelist[DEMONLORD+4] = ' ';
  867.         monstnamelist[DEMONLORD+5] = ' ';
  868.         monstnamelist[DEMONLORD+6] = ' ';
  869.         monstnamelist[DEMONPRINCE] = ' ';
  870.         monstnamelist[LUCIFER] = ' ';
  871.         cursors();
  872.         return;
  873.     case OPOTION:    
  874.     case OSCROLL:    
  875.         return;
  876.  
  877.     default:    
  878.         flag=1;
  879.     };
  880.     if (flag) bottomline();
  881.  
  882.     for (i=0;i<6;i++)
  883.         if (c[i] < 3)
  884.             c[i] = 3;
  885. }
  886.  
  887. /*
  888.     function to read a string from token input "string"
  889.     returns a pointer to the string
  890.  */
  891. gettokstr(str)
  892. register char *str;
  893. {
  894.     register int i,j;
  895.  
  896.     i=50;
  897.     while ((getcharacter() != '"') && (--i > 0));
  898.     i=36;
  899.     while (--i > 0) {
  900.         if ((j=getcharacter()) != '"') *str++ = j;  
  901.         else i=0;
  902.     }
  903.     *str = 0;
  904.     i=50;
  905.     if (j != '"') while ((getcharacter() != '"') && (--i > 0)); /* if end due to too long, then find closing quote */
  906. }
  907.  
  908. /*
  909.     function to ask user for a password (no echo)
  910.     returns 1 if entered correctly, 0 if not
  911.  */
  912. static char gpwbuf[33];
  913.  
  914. getpassword()
  915. {
  916.     register int i,j;
  917.     register char *gpwp;
  918.     extern char *password;
  919.  
  920.     scbr();    /*    system("stty -echo cbreak"); */
  921.     gpwp = gpwbuf;    
  922.     lprcat("\nEnter Password: "); 
  923.     lflush();
  924.     i = strlen(password);
  925.     for (j=0; j<i; j++) read(0,gpwp++,1);      
  926.     gpwbuf[i]=0;
  927.     sncbr(); /* system("stty echo -cbreak"); */
  928.     if (strcmp(gpwbuf,password) != 0) {    
  929.         lprcat("\nSorry\n");  
  930.         lflush();
  931.         return(0);
  932.     }
  933.     else  return(1);
  934. }
  935.  
  936. /*
  937.     subroutine to get a yes or no response from the user
  938.     returns y or n
  939.  */
  940. getyn()
  941. {
  942.     register int i;
  943.  
  944.     i=0; 
  945.     while (i!='y' && i!='n' && i!='\33') i=getcharacter();
  946.     return(i);
  947. }
  948.  
  949. /*
  950.     function to calculate the pack weight of the player
  951.     returns the number of pounds the player is carrying
  952.  */
  953. packweight()
  954. {
  955.     register int i,j,k;
  956.  
  957.     k=c[GOLD]/1000; 
  958.     j=25;  
  959.     while ((iven[j]==0) && (j>0)) --j;
  960.     for (i=0; i<=j; i++)
  961.         switch(iven[i]) {
  962.         case 0:
  963.             break;
  964.         case OSSPLATE:   
  965.         case OPLATEARMOR: 
  966.             k += 40;
  967.             break;
  968.         case OPLATE:
  969.             k += 35;    
  970.             break;
  971.         case OHAMMER:    
  972.             k += 30;    
  973.             break;
  974.         case OSPLINT:    
  975.             k += 26;    
  976.             break;
  977.  
  978.         case OCHAIN:
  979.         case OBATTLEAXE:           
  980.         case O2SWORD:        
  981.             k += 23;    
  982.             break;
  983.  
  984.         case OLONGSWORD:
  985.         case OPSTAFF:
  986.         case OSWORD:
  987.         case ORING:
  988.         case OFLAIL:        
  989.             k += 20;    
  990.             break;
  991.  
  992.         case OELVENCHAIN:     
  993.         case OSWORDofSLASHING:    
  994.         case OLANCE:
  995.         case OSLAYER:
  996.         case OSTUDLEATHER:    
  997.             k += 15;    
  998.             break;
  999.  
  1000.  
  1001.         case OLEATHER:
  1002.         case OSPEAR:        
  1003.             k += 8;        
  1004.             break;
  1005.  
  1006.         case OORBOFDRAGON:
  1007.         case OORB:
  1008.         case OBELT:        
  1009.             k += 4;        
  1010.             break;
  1011.  
  1012.         case OSHIELD:        
  1013.             k += 7;        
  1014.             break;
  1015.         case OCHEST:        
  1016.             k += 30 + ivenarg[i];    
  1017.             break;
  1018.         default:        
  1019.             k++;
  1020.         };
  1021.     return(k);
  1022. }
  1023.